package com.jgp.sys.repository;

import com.jgp.common.pojo.TreeBean;
import com.jgp.sys.query.OrderList;
import com.jgp.sys.query.QueryFilterList;
import com.jgp.sys.query.power.DataPowerConfig;
import com.jgp.sys.ui.Pager;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * 平台基础Repository
 * 项目   sys
 * 作者   loufei
 * 时间   2018/2/25
 */
@NoRepositoryBean
public interface JGPRepository<M, ID extends Serializable> extends Repository<M, ID> {
    
    M createOrUpdate(M m);
    
    /**
     * 创建数据库对象
     * 整体更新
     *
     * @param m 久化对象
     * @return 当前持久化对象
     */
    M create(M m);
    
    /**
     * 批量创建数据库对象
     * 此方法会过滤掉存在id的对象
     *
     * @param ms 久化集合
     * @return 当前持久化集合
     */
    List<M> createInBatch(List<M> ms);
    
    
    /**
     * 更新一个数据库对象
     * 可指定需要更新的字段 其他字段不会更新
     * 若 columns 为空则 全部字段更新
     *
     * @param m       久化对象
     * @param columns 需要更新模型字段（即是数据库列）
     * @return 当前持久化对象
     */
    M update(M m, String... columns);
    
    /**
     * 更新一个数据库对象
     * 可指定需要排除更新的字段 其他字段参与更新
     * 若 columns 为空则 全部字段更新
     *
     * @param m       久化对象
     * @param columns 需要排除模型字段（即是数据库列）
     * @return 当前持久化对象
     */
    M updateExcludes(M m, String... columns);
    
    /**
     * 批量 更新数据库对象
     * 可指定需要更新的字段 其他字段不会更新
     * 若 columns 为空则 全部字段更新
     *
     * @param ms      对象集合
     * @param columns 需要更新模型字段（即是数据库列）
     * @return 返回更新记录数 返回数量小于等于与传入集合数量，应为会过滤掉id为空的
     */
    long updateInBatch(List<M> ms, String... columns);
    
    /**
     * 批量 更新数据库对象
     * 可指定需要排除的字段 其他字段参与更新
     * 若 columns 为空则 全部字段更新
     *
     * @param ms      对象集合
     * @param columns 需要排除的模型字段（即是数据库列）
     * @return 返回更新记录数 返回数量小于等于与传入集合数量，应为会过滤掉id为空的
     */
    long updateInBatchExcludes(List<M> ms, String... columns);
    
    /**
     * @param id id
     */
    void delete(ID id);
    
    /**
     * 删除对象
     * 通过设置delFlag=true 使得模型可以被delFlag过滤掉
     * 并不是真的删除
     *
     * @param m 要删除的对象
     */
    void delete(M m);
    
    /**
     * 批量删除对象
     * 通过设置delFlag=true 使得模型可以被delFlag过滤掉
     * 并不是真的删除
     *
     * @param ms 要删除的集合
     */
    void deleteInBatch(List<M> ms);
    
    /**
     * 持久删除
     * 真的在数据库中删除记录
     *
     * @param m 要删除的对象
     */
    void deletePersist(M m);
    
    /**
     * 持久删除
     * 真的在数据库中删除记录
     *
     * @param id id
     */
    void deletePersist(ID id);
    
    /**
     * 持久删除 批量删除
     * 真的在数据库中删除记录
     *
     * @param ms 要删除的集合
     */
    void deleteInBatchPersist(List<M> ms);
    
    /**
     * 持久删除 批量删除
     * 真的在数据库中删除记录
     *
     * @param ids id集合
     */
    void deleteInBatchPersistByIds(List<ID> ids);
    
    /**
     * 删除所有 非持久化删除
     */
    void deleteAll();
    
    /**
     * 删除所有 持久化删除
     */
    void deleteAllPersist();
    
    
    /**
     * 删除符合条件的数据
     * 假删除
     *
     * @param filters 查询条件
     * @return 删除条数
     */
    long delete(QueryFilterList filters);
    
    /**
     * 删除符合条件的数据
     * 真删除
     *
     * @param filters 查询条件
     * @return 删除条数
     */
    long deletePersist(QueryFilterList filters);
    
    
    M readOne(QueryFilterList filters);
    
    M readOnePersist(QueryFilterList filters);
    
    List<M> read(QueryFilterList filters, String... columns);
    
    M read(ID id);
    
    List<M> read(Collection<ID> ids);
    
    List<M> readAll();
    
    List<M> readAllPower(DataPowerConfig powerConfig);
    
    List<M> readAll(List<ID> ids);
   
    M readPersist(ID id);
    
    List<M> readPersist(Collection<ID> ids);
  
    List<M> readAllPersist();
    
    List<M> readAllPersistPower(DataPowerConfig powerConfig);
    
    List<M> readAllPersist(Collection<ID> ids);
    
    List<M> read(QueryFilterList filters);
    
    List<M> read(QueryFilterList filters,SpecPredicate<M> spec);
    
    List<M> readPower(QueryFilterList filters, DataPowerConfig powerConfig);
    
    List<M> readPower(QueryFilterList filters,SpecPredicate<M> spec, DataPowerConfig powerConfig);
 
    List<M> read(QueryFilterList filters, Pager pager);
    
    List<M> read(QueryFilterList filters,SpecPredicate<M> spec, Pager pager);
    
    List<M> readPower(QueryFilterList filters,Pager pager, DataPowerConfig powerConfig);
    
    List<M> readPower(QueryFilterList filters,SpecPredicate<M> spec,Pager pager, DataPowerConfig powerConfig);
    
    List<M> read(QueryFilterList filters, OrderList orders);
    
    List<M> read(QueryFilterList filters, OrderList orders,SpecPredicate<M> spec);
    
    List<M> readPower(QueryFilterList filters,OrderList orders, DataPowerConfig powerConfig);
    
    List<M> readPower(QueryFilterList filters,OrderList orders,SpecPredicate<M> spec, DataPowerConfig powerConfig);

    List<M> read(QueryFilterList filters, OrderList orders, Pager pager);
    
    List<M> read(QueryFilterList filters, OrderList orders,SpecPredicate<M> spec, Pager pager);
    
    List<M> readPower(QueryFilterList filters,OrderList orders, Pager pager, DataPowerConfig powerConfig);
    
    List<M> readPower(QueryFilterList filters,OrderList orders,SpecPredicate<M> spec, Pager pager, DataPowerConfig powerConfig);
    
    List<Map<String, Object>> readNativeSqlToMap(String countSql, String sql, Pager pager);
    
    List<Map<String, Object>> readNativeSqlToMapWithOutTransformName(String countSql, String sql, Pager pager);
    
    List<M> readNativeSql(String countSql, String sql, Pager pager);
    
    List<Map<String, Object>> readNativeSqlToMap(String sql);
    
    List<M> readNativeSql(String sql);
    
    Map<String, Object> readOneNativeSqlToMap(String sql);
    
    M readOneNativeSql(String sql);
    
    int executeNativeSql(String sql, Object... params);
    
    List<M> readPersist(QueryFilterList filters);
    
    List<M> readPersist(QueryFilterList filters,SpecPredicate<M> spec);
    
    List<M> readPersistPower(QueryFilterList filters, DataPowerConfig powerConfig);
    
    List<M> readPersistPower(QueryFilterList filters,SpecPredicate<M> spec, DataPowerConfig powerConfig);
    
    List<M> readPersist(QueryFilterList filters, Pager pager);
    
    List<M> readPersist(QueryFilterList filters,SpecPredicate<M> spec, Pager pager);
    
    List<M> readPersistPower(QueryFilterList filters, Pager pager, DataPowerConfig powerConfig);
    
    List<M> readPersistPower(QueryFilterList filters,SpecPredicate<M> spec, Pager pager, DataPowerConfig powerConfig);
    
    List<M> readPersist(QueryFilterList filters, OrderList orders);
    
    List<M> readPersist(QueryFilterList filters, OrderList orders,SpecPredicate<M> spec);
    
    List<M> readPersistPower(QueryFilterList filters, OrderList orders, DataPowerConfig powerConfig);
    
    List<M> readPersistPower(QueryFilterList filters, OrderList orders, SpecPredicate<M> spec, DataPowerConfig powerConfig);
    
    List<M> readPersist(QueryFilterList filters, OrderList orders, Pager pager);
    
    List<M> readPersist(QueryFilterList filters, OrderList orders,SpecPredicate<M> spec, Pager pager);
    
    List<M> readPersistPower(QueryFilterList filters, OrderList orders, Pager pager, DataPowerConfig powerConfig);
    
    List<M> readPersistPower(QueryFilterList filters, OrderList orders, SpecPredicate<M> spec, Pager pager, DataPowerConfig powerConfig);
    
    long countAll();
    
    long countAllPersist();
    
    long count(QueryFilterList filters);
    
    long count(QueryFilterList filters,SpecPredicate<M> spec);
    
    long countPower(QueryFilterList filters, DataPowerConfig powerConfig);
    
    long countPower(QueryFilterList filters,SpecPredicate<M> spec, DataPowerConfig powerConfig);
    
    long countPersist(QueryFilterList filters);
    
    long countPersist(QueryFilterList filters,SpecPredicate<M> spec);
    
    long countPersistPower(QueryFilterList filters, DataPowerConfig powerConfig);
    
    long countPersistPower(QueryFilterList filters,SpecPredicate<M> spec, DataPowerConfig powerConfig);
    
    List<TreeBean> queryTree(QueryFilterList filters, OrderList orders);
    
    List<TreeBean> queryTreeFromBottomToTop(ID nodeId);
    
    List<TreeBean> queryTreeFromBottomToTop(List<ID> nodeIds);
    
    List<ID> deleteTreeItemAndAllChildren(QueryFilterList filters);
    
}


